package net.cyue.easyconfiguration.node.util;

import net.cyue.easyconfiguration.api.IConfigurationResource;
import net.cyue.util.StringUtil;

import java.util.ArrayList;
import java.util.List;
import java.util.logging.Logger;

public class NodePathUtil {

    public static final String PATH_SEPARATOR = ".";
    private static final Logger LOGGER = Logger.getLogger(NodePathUtil.class.getName());

    public static String getNameFromPath(String path) {
        if (StringUtil.isBlank(path)) {
            throw new IllegalArgumentException("Path cannot be blank");
        }
        path = NodePathUtil.normalizePath(path);
        return path.substring(path.lastIndexOf(NodePathUtil.PATH_SEPARATOR) + 1);
    }

    public static String normalizePath(String path) {
        if (StringUtil.isBlank(path)) {
            throw new IllegalArgumentException("Path cannot be blank");
        }
        return path.replaceAll("/", PATH_SEPARATOR);
    }
    public static String[] normalizePaths(String... paths) {
        String[] normalizedPaths = new String[paths.length];
        for (int i = 0; i < paths.length; i++) {
            normalizedPaths[i] = normalizePath(paths[i]);
        }
        return normalizedPaths;
    }

    /**
     * 校验路径格式是否合法（支持中文和单独*匹配所有一级路径）
     * 合法路径规则：
     * 1. 允许包含中文字符、字母、数字、下划线、连字符、点号(.)和通配符(*)
     * 2. 点号(.)用于分隔路径片段，不能连续出现(如"a..b"不合法)
     * 3. 不能以点号(.)开头或结尾(空路径和单独*除外)
     * 4. 通配符(*)可以作为独立片段或片段中的一部分
     * 5. 单独的*是合法的，表示匹配所有一级路径
     * 6. 空路径视为合法
     *
     * @param path 待校验的路径
     * @return 校验结果，true表示合法，false表示非法
     */
    public static boolean isValidPath(String path) {
        // 空路径视为合法
        if (path == null || path.trim().isEmpty()) {
            return true;
        }
        String trimmedPath = path.trim();

        // 单独的*是合法的，表示匹配所有一级路径
        if ("*".equals(trimmedPath)) {
            return true;
        }

        // 检查是否以点号开头或结尾
        if (trimmedPath.startsWith(".") || trimmedPath.endsWith(".")) {
            return false;
        }

        // 检查是否包含连续的点号
        if (trimmedPath.contains("..")) {
            return false;
        }

        // 检查是否包含无效字符（允许中文、字母、数字、下划线、连字符、点号和星号）
        // 中文字符的Unicode范围：\u4e00-\u9fa5
        if (!trimmedPath.matches("^[\\u4e00-\\u9fa5a-zA-Z0-9_\\-.*]+$")) {
            return false;
        }

        // 检查是否全为通配符加dots（如"*.*"、"*.*.*"等都是不合法的）
        String allWildcardWithDotsPattern = "^(\\*\\.)+\\*$";
        if (trimmedPath.matches(allWildcardWithDotsPattern)) {
            return false;
        }

        // 检查路径片段是否合法
        String[] parts = trimmedPath.split("\\.");
        for (String part : parts) {
            // 片段不能为空（由于前面已检查连续点号，这里主要防止极端情况）
            if (part.isEmpty()) {
                return false;
            }
        }

        return true;
    }

    /**
     * 判断路径是否为WildcardPath（包含通配符，可能对应多个值）
     * @param path 要判断的路径
     * @return 如果路径包含通配符(*)则返回true，否则返回false
     */
    public static boolean isWildcardPath(String path) {
        // 校验路径合法性
        if (!isValidPath(path)) {
            LOGGER.warning("Invalid path: " + path);
            return false;
        }

        // 空路径不视为WildcardPath
        if (path == null || path.trim().isEmpty()) {
            return false;
        }

        String trimmedPath = path.trim();

        // 检查路径中是否包含通配符(*)
        return trimmedPath.contains("*");
    }

    public static boolean hasWildcardPath(String... paths) {
        for (String path : paths) {
            if (isWildcardPath(path)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 简单的通配符模式匹配
     */
    private static boolean matchesPattern(String str, String pattern) {
        String regex = pattern.replace("*", ".*");
        return str.matches(regex);
    }
    /**
     * 递归处理带通配符的路径片段
     */
    private static void processWildcardParts(
        IConfigurationResource resource,
        List<String> result,
        String currentPath,
        String[] parts,
        int index
    ) {
        if (index == parts.length) {
            result.add(currentPath);
            return;
        }

        String part = parts[index];
        String parentPath = currentPath.isEmpty() ? "" : currentPath;

        if (part.equals("*")) {
            // 当前部分是通配符，获取所有子键
            List<String> childKeys = resource.getTableKeyList(parentPath);
            for (String child : childKeys) {
                String childPath = currentPath.isEmpty() ? child : currentPath + "." + child;
                processWildcardParts(resource, result, childPath, parts, index + 1);
            }
        } else if (part.contains("*")) {
            // 处理包含通配符的片段（如"a*b"）
            List<String> childKeys = resource.getTableKeyList(parentPath);
            for (String child : childKeys) {
                if (matchesPattern(child, part)) {
                    String childPath = currentPath.isEmpty() ? child : currentPath + "." + child;
                    processWildcardParts(resource, result, childPath, parts, index + 1);
                }
            }
        } else {
            // 普通路径片段，继续处理下一部分
            String newPath = currentPath.isEmpty() ? part : currentPath + "." + part;
            processWildcardParts(resource, result, newPath, parts, index + 1);
        }
    }
    public static List<String> processPaths(
        IConfigurationResource resource,
        String... paths
    ) {
        List<String> pathList = new ArrayList<>();
        for (String path : paths) {
            if (!isValidPath(path)) {
                LOGGER.warning("Invalid path: " + path);
                continue;
            }
            if (path.contains("*")) {
                // 检查是否是单纯的xxx.*形式（最后一部分是*且只有一个*）
                String[] parts = path.split("\\.");
                if (
                    parts.length > 0 &&
                    parts[parts.length - 1].equals("*") &&
                    path.indexOf("*") == path.lastIndexOf("*")
                ) {
                    // 处理a.*这种简单形式 - 组合成完整路径
                    int lastIndex = path.length() - 2;
                    if (lastIndex < 0) {
                        lastIndex = 0;
                    }
                    String basePath = path.substring(0, lastIndex);
                    List<String> childKeys = resource.getTableKeyList(basePath);
                    for (String child : childKeys) {
                        // 构建完整路径，避免basePath为空时出现多余的点号
                        String fullPath = basePath.isEmpty() ? child : basePath + "." + child;
                        pathList.add(fullPath);
                    }
                } else {
                    // 处理复杂通配符如a.*.b.*，a.*.*等
                    processWildcardParts(resource, pathList, "", parts, 0);
                }
                continue;
            }
            // 不包含通配符
            pathList.add(path);
        }
        return pathList;
    }

}
